{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DAY50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在我们思考下，是否可以对于预训练模型增加模块来优化其效果，这里我们会遇到一个问题\n",
    "\n",
    "预训练模型的结构和权重是固定的，如果修改其中的模型结构，是否会大幅影响其性能。其次是训练的时候如何训练才可以更好的避免破坏原有的特征提取器的参数。\n",
    "\n",
    "所以今天的内容，我们需要回答2个问题。\n",
    "\n",
    "1. resnet18中如何插入cbam模块？\n",
    "2. 采用什么样的预训练策略，能够更好的提高效率？\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以很明显的想到，如果是resnet18+cbam模块，那么大多数地方的代码都是可以复用的，模型定义部分需要重写。先继续之前的代码\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "所以很容易的想到之前第一次使用resnet的预训练策略：先冻结预训练层，然后训练其他层。之前的其它层是全连接层（分类头），现在其它层还包含了每一个残差块中的cbam注意力层。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## resnet结构解析\n",
    "\n",
    "先复用下数据预处理+定义cbam的代码，然后看下resnet内部的结构是什么，这决定我们如何插入模块\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "使用设备: cuda\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# 定义通道注意力\n",
    "class ChannelAttention(nn.Module):\n",
    "    def __init__(self, in_channels, ratio=16):\n",
    "        \"\"\"\n",
    "        通道注意力机制初始化\n",
    "        参数:\n",
    "            in_channels: 输入特征图的通道数\n",
    "            ratio: 降维比例，用于减少参数量，默认为16\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "        # 全局平均池化，将每个通道的特征图压缩为1x1，保留通道间的平均值信息\n",
    "        self.avg_pool = nn.AdaptiveAvgPool2d(1)\n",
    "        # 全局最大池化，将每个通道的特征图压缩为1x1，保留通道间的最显著特征\n",
    "        self.max_pool = nn.AdaptiveMaxPool2d(1)\n",
    "        # 共享全连接层，用于学习通道间的关系\n",
    "        # 先降维（除以ratio），再通过ReLU激活，最后升维回原始通道数\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(in_channels, in_channels // ratio, bias=False),  # 降维层\n",
    "            nn.ReLU(),  # 非线性激活函数\n",
    "            nn.Linear(in_channels // ratio, in_channels, bias=False)   # 升维层\n",
    "        )\n",
    "        # Sigmoid函数将输出映射到0-1之间，作为各通道的权重\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        前向传播函数\n",
    "        参数:\n",
    "            x: 输入特征图，形状为 [batch_size, channels, height, width]\n",
    "        返回:\n",
    "            调整后的特征图，通道权重已应用\n",
    "        \"\"\"\n",
    "        # 获取输入特征图的维度信息，这是一种元组的解包写法\n",
    "        b, c, h, w = x.shape\n",
    "        # 对平均池化结果进行处理：展平后通过全连接网络\n",
    "        avg_out = self.fc(self.avg_pool(x).view(b, c))\n",
    "        # 对最大池化结果进行处理：展平后通过全连接网络\n",
    "        max_out = self.fc(self.max_pool(x).view(b, c))\n",
    "        # 将平均池化和最大池化的结果相加并通过sigmoid函数得到通道权重\n",
    "        attention = self.sigmoid(avg_out + max_out).view(b, c, 1, 1)\n",
    "        # 将注意力权重与原始特征相乘，增强重要通道，抑制不重要通道\n",
    "        return x * attention #这个运算是pytorch的广播机制\n",
    "\n",
    "## 空间注意力模块\n",
    "class SpatialAttention(nn.Module):\n",
    "    def __init__(self, kernel_size=7):\n",
    "        super().__init__()\n",
    "        self.conv = nn.Conv2d(2, 1, kernel_size, padding=kernel_size//2, bias=False)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "\n",
    "    def forward(self, x):\n",
    "        # 通道维度池化\n",
    "        avg_out = torch.mean(x, dim=1, keepdim=True)  # 平均池化：(B,1,H,W)\n",
    "        max_out, _ = torch.max(x, dim=1, keepdim=True)  # 最大池化：(B,1,H,W)\n",
    "        pool_out = torch.cat([avg_out, max_out], dim=1)  # 拼接：(B,2,H,W)\n",
    "        attention = self.conv(pool_out)  # 卷积提取空间特征\n",
    "        return x * self.sigmoid(attention)  # 特征与空间权重相乘\n",
    "\n",
    "## CBAM模块\n",
    "class CBAM(nn.Module):\n",
    "    def __init__(self, in_channels, ratio=16, kernel_size=7):\n",
    "        super().__init__()\n",
    "        self.channel_attn = ChannelAttention(in_channels, ratio)\n",
    "        self.spatial_attn = SpatialAttention(kernel_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.channel_attn(x)\n",
    "        x = self.spatial_attn(x)\n",
    "        return x\n",
    "    \n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# 设置中文字体支持\n",
    "plt.rcParams[\"font.family\"] = [\"SimHei\"]\n",
    "plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题\n",
    "\n",
    "# 检查GPU是否可用\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"使用设备: {device}\")\n",
    "\n",
    "# 数据预处理（与原代码一致）\n",
    "train_transform = transforms.Compose([\n",
    "    transforms.RandomCrop(32, padding=4),\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),\n",
    "    transforms.RandomRotation(15),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n",
    "])\n",
    "\n",
    "test_transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n",
    "])\n",
    "\n",
    "# 加载数据集（与原代码一致）\n",
    "train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=train_transform)\n",
    "test_dataset = datasets.CIFAR10(root='./data', train=False, transform=test_transform)\n",
    "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "先通过预训练resnet18来查看模型结构"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "==========================================================================================\n",
       "Layer (type:depth-idx)                   Output Shape              Param #\n",
       "==========================================================================================\n",
       "ResNet                                   [1, 1000]                 --\n",
       "├─Conv2d: 1-1                            [1, 64, 112, 112]         9,408\n",
       "├─BatchNorm2d: 1-2                       [1, 64, 112, 112]         128\n",
       "├─ReLU: 1-3                              [1, 64, 112, 112]         --\n",
       "├─MaxPool2d: 1-4                         [1, 64, 56, 56]           --\n",
       "├─Sequential: 1-5                        [1, 64, 56, 56]           --\n",
       "│    └─BasicBlock: 2-1                   [1, 64, 56, 56]           --\n",
       "│    │    └─Conv2d: 3-1                  [1, 64, 56, 56]           36,864\n",
       "│    │    └─BatchNorm2d: 3-2             [1, 64, 56, 56]           128\n",
       "│    │    └─ReLU: 3-3                    [1, 64, 56, 56]           --\n",
       "│    │    └─Conv2d: 3-4                  [1, 64, 56, 56]           36,864\n",
       "│    │    └─BatchNorm2d: 3-5             [1, 64, 56, 56]           128\n",
       "│    │    └─ReLU: 3-6                    [1, 64, 56, 56]           --\n",
       "│    └─BasicBlock: 2-2                   [1, 64, 56, 56]           --\n",
       "│    │    └─Conv2d: 3-7                  [1, 64, 56, 56]           36,864\n",
       "│    │    └─BatchNorm2d: 3-8             [1, 64, 56, 56]           128\n",
       "│    │    └─ReLU: 3-9                    [1, 64, 56, 56]           --\n",
       "│    │    └─Conv2d: 3-10                 [1, 64, 56, 56]           36,864\n",
       "│    │    └─BatchNorm2d: 3-11            [1, 64, 56, 56]           128\n",
       "│    │    └─ReLU: 3-12                   [1, 64, 56, 56]           --\n",
       "├─Sequential: 1-6                        [1, 128, 28, 28]          --\n",
       "│    └─BasicBlock: 2-3                   [1, 128, 28, 28]          --\n",
       "│    │    └─Conv2d: 3-13                 [1, 128, 28, 28]          73,728\n",
       "│    │    └─BatchNorm2d: 3-14            [1, 128, 28, 28]          256\n",
       "│    │    └─ReLU: 3-15                   [1, 128, 28, 28]          --\n",
       "│    │    └─Conv2d: 3-16                 [1, 128, 28, 28]          147,456\n",
       "│    │    └─BatchNorm2d: 3-17            [1, 128, 28, 28]          256\n",
       "│    │    └─Sequential: 3-18             [1, 128, 28, 28]          8,448\n",
       "│    │    └─ReLU: 3-19                   [1, 128, 28, 28]          --\n",
       "│    └─BasicBlock: 2-4                   [1, 128, 28, 28]          --\n",
       "│    │    └─Conv2d: 3-20                 [1, 128, 28, 28]          147,456\n",
       "│    │    └─BatchNorm2d: 3-21            [1, 128, 28, 28]          256\n",
       "│    │    └─ReLU: 3-22                   [1, 128, 28, 28]          --\n",
       "│    │    └─Conv2d: 3-23                 [1, 128, 28, 28]          147,456\n",
       "│    │    └─BatchNorm2d: 3-24            [1, 128, 28, 28]          256\n",
       "│    │    └─ReLU: 3-25                   [1, 128, 28, 28]          --\n",
       "├─Sequential: 1-7                        [1, 256, 14, 14]          --\n",
       "│    └─BasicBlock: 2-5                   [1, 256, 14, 14]          --\n",
       "│    │    └─Conv2d: 3-26                 [1, 256, 14, 14]          294,912\n",
       "│    │    └─BatchNorm2d: 3-27            [1, 256, 14, 14]          512\n",
       "│    │    └─ReLU: 3-28                   [1, 256, 14, 14]          --\n",
       "│    │    └─Conv2d: 3-29                 [1, 256, 14, 14]          589,824\n",
       "│    │    └─BatchNorm2d: 3-30            [1, 256, 14, 14]          512\n",
       "│    │    └─Sequential: 3-31             [1, 256, 14, 14]          33,280\n",
       "│    │    └─ReLU: 3-32                   [1, 256, 14, 14]          --\n",
       "│    └─BasicBlock: 2-6                   [1, 256, 14, 14]          --\n",
       "│    │    └─Conv2d: 3-33                 [1, 256, 14, 14]          589,824\n",
       "│    │    └─BatchNorm2d: 3-34            [1, 256, 14, 14]          512\n",
       "│    │    └─ReLU: 3-35                   [1, 256, 14, 14]          --\n",
       "│    │    └─Conv2d: 3-36                 [1, 256, 14, 14]          589,824\n",
       "│    │    └─BatchNorm2d: 3-37            [1, 256, 14, 14]          512\n",
       "│    │    └─ReLU: 3-38                   [1, 256, 14, 14]          --\n",
       "├─Sequential: 1-8                        [1, 512, 7, 7]            --\n",
       "│    └─BasicBlock: 2-7                   [1, 512, 7, 7]            --\n",
       "│    │    └─Conv2d: 3-39                 [1, 512, 7, 7]            1,179,648\n",
       "│    │    └─BatchNorm2d: 3-40            [1, 512, 7, 7]            1,024\n",
       "│    │    └─ReLU: 3-41                   [1, 512, 7, 7]            --\n",
       "│    │    └─Conv2d: 3-42                 [1, 512, 7, 7]            2,359,296\n",
       "│    │    └─BatchNorm2d: 3-43            [1, 512, 7, 7]            1,024\n",
       "│    │    └─Sequential: 3-44             [1, 512, 7, 7]            132,096\n",
       "│    │    └─ReLU: 3-45                   [1, 512, 7, 7]            --\n",
       "│    └─BasicBlock: 2-8                   [1, 512, 7, 7]            --\n",
       "│    │    └─Conv2d: 3-46                 [1, 512, 7, 7]            2,359,296\n",
       "│    │    └─BatchNorm2d: 3-47            [1, 512, 7, 7]            1,024\n",
       "│    │    └─ReLU: 3-48                   [1, 512, 7, 7]            --\n",
       "│    │    └─Conv2d: 3-49                 [1, 512, 7, 7]            2,359,296\n",
       "│    │    └─BatchNorm2d: 3-50            [1, 512, 7, 7]            1,024\n",
       "│    │    └─ReLU: 3-51                   [1, 512, 7, 7]            --\n",
       "├─AdaptiveAvgPool2d: 1-9                 [1, 512, 1, 1]            --\n",
       "├─Linear: 1-10                           [1, 1000]                 513,000\n",
       "==========================================================================================\n",
       "Total params: 11,689,512\n",
       "Trainable params: 11,689,512\n",
       "Non-trainable params: 0\n",
       "Total mult-adds (G): 1.81\n",
       "==========================================================================================\n",
       "Input size (MB): 0.60\n",
       "Forward/backward pass size (MB): 39.75\n",
       "Params size (MB): 46.76\n",
       "Estimated Total Size (MB): 87.11\n",
       "=========================================================================================="
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "import torchvision.models as models\n",
    "from torchinfo import summary #之前的内容说了，推荐用他来可视化模型结构，信息最全\n",
    "\n",
    "# 加载 ResNet18（预训练）\n",
    "model = models.resnet18(pretrained=True)\n",
    "model.eval()\n",
    "\n",
    "# 输出模型结构和参数概要\n",
    "summary(model, input_size=(1, 3, 224, 224))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "经典的 ResNet-18 模型可以将其看作一个处理流水线，图像数据从一端进去，分类结果从另一端出来。整个过程可以分为三个主要部分：\n",
    "\n",
    "\n",
    "| 阶段 (Stage)     | 对应层级 (Layers)                                  | 主要作用                                                                                             |\n",
    "| :--------------- | :------------------------------------------------- | :--------------------------------------------------------------------------------------------------- |\n",
    "| **1. 输入预处理 (Stem)** | `Conv2d: 1-1` 到 `MaxPool2d: 1-4`                  | 对输入图像进行初步的特征提取，并通过池化操作将特征图尺寸减半，为后续处理做准备。                   |\n",
    "| **2. 核心特征提取**  | 四个 `Sequential` 模块 (`1-5` 到 `1-8`)              | 这是网络的主体，由多个残差块（`BasicBlock`）堆叠而成，负责从浅到深、从粗到细地学习图像特征。 |\n",
    "| **3. 分类输出 (Head)**   | `AdaptiveAvgPool2d: 1-9` 和 `Linear: 1-10` | 将最终的特征图（feature map）转换成一个特征向量，并通过全连接层映射到最终的 1000 个类别上。  |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "假设输入图像尺寸为 `[1, 3, 224, 224]` (Batch, Channels, Height, Width)，具体shape变化如下\n",
    "\n",
    "| 阶段 / 层级                                 | 输出尺寸             | 通道数变化        | 尺寸变化                  | 关键操作和说明                                                                                        |\n",
    "| :------------------------------------------ | :------------------- | :---------------- | :------------------------ | :---------------------------------------------------------------------------------------------------- |\n",
    "| **输入**                                    | `[1, 3, 224, 224]`   | -                 | -                         | 初始输入图像。                                                                                        |\n",
    "| **1. 输入预处理 (Stem)**                      |                      |                   |                           |                                                                                                       |\n",
    "| `Conv2d: 1-1` (7x7, stride=2)               | `[1, 64, 112, 112]`  | `3 -> 64`         | `224x224 -> 112x112`      | 大卷积核快速提取初始特征，步长为2使尺寸减半。                                                       |\n",
    "| `MaxPool2d: 1-4` (3x3, stride=2)            | `[1, 64, 56, 56]`    | 不变              | `112x112 -> 56x56`        | 再次进行池化，进一步减小尺寸，减少计算量。                                                          |\n",
    "| **2. 核心特征提取**                         |                      |                   |                           |                                                                                                       |\n",
    "| **Stage 1** (`Sequential: 1-5`, 2个BasicBlock) | `[1, 64, 56, 56]`    | 不变 (`64 -> 64`)   | 不变 (`56x56`)              | 包含2个标准的`BasicBlock`，深化特征，但保持尺寸和通道数不变。                                     |\n",
    "| **Stage 2** (`Sequential: 1-6`, 2个BasicBlock) | `[1, 128, 28, 28]`   | `64 -> 128`       | `56x56 -> 28x28`          | **尺寸减半，通道加倍**。第一个`BasicBlock` (2-3) 负责这个转换（这种块也叫 \"downsampling block\"）。 |\n",
    "| **Stage 3** (`Sequential: 1-7`, 2个BasicBlock) | `[1, 256, 14, 14]`   | `128 -> 256`      | `28x28 -> 14x14`          | **尺寸减半，通道加倍**。同样由该阶段的第一个`BasicBlock` (2-5) 完成。                                |\n",
    "| **Stage 4** (`Sequential: 1-8`, 2个BasicBlock) | `[1, 512, 7, 7]`     | `256 -> 512`      | `14x14 -> 7x7`            | **尺寸减半，通道加倍**。由该阶段的第一个`BasicBlock` (2-7) 完成。                                     |\n",
    "| **3. 分类输出 (Head)**                      |                      |                   |                           |                                                                                                       |\n",
    "| `AdaptiveAvgPool2d: 1-9`                    | `[1, 512, 1, 1]`     | 不变              | `7x7 -> 1x1`              | 全局平均池化，将每个通道的 `7x7` 特征图压缩成一个值，得到一个长度为 512 的特征向量。                  |\n",
    "| `Linear: 1-10`                              | `[1, 1000]`          | `512 -> 1000`     | -                         | 全连接层，将 512 维的特征向量映射到 1000 个类别得分上。                                               |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里我们先介绍下basic block，他是残差网络最重要的思想，在 ResNet 出现之前，人们普遍认为神经网络越深，性能就越好。但实践发现，当网络堆叠到一定深度后，再增加层数，模型的准确率反而会下降。这种现象不叫“过拟合”（Overfitting），因为不光是测试集，连训练集上的准确率都在下降。这被称为 “网络退化”（Degradation） 问题。\n",
    "\n",
    "本质是因为卷积和池化都是在做下采样的过程，越深虽然能够提取越重要的信息，但是很多重要的信息都被丢弃了。它意味着，让一个很深的网络去学习一个简单的恒等变换（即 输出 = 输入）都非常困难。\n",
    "\n",
    "BasicBlock 的设计者何恺明博士等人提出了一个绝妙的想法：与其让网络层直接学习一个目标映射 H(x)，不如让它学习这个映射与输入 x 之间的“差值”，即残差（Residual）F(x) = H(x) - x。这样，原始的目标映射就变成了 H(x) = F(x) + x\n",
    "\n",
    "这个简单的改动为什么如此强大？\n",
    "\n",
    "- 简化学习目标：想象一个极端情况，如果某一层的最佳状态就是“什么都不做”（即恒等变换 H(x)=x），那么网络只需要让残差部分 F(x) 的输出为 0 即可。让权重趋向于 0 比让一堆非线性层拟合一个恒等变换要容易得多。\n",
    "\n",
    "- 信息高速公路： + x 这部分操作被称为“快捷连接”（Shortcut Connection）或“跳跃连接”（Skip Connection）。它像一条高速公路，允许输入信息 x 直接“跳”到更深的层，避免了在层层传递中信息丢失或梯度消失的问题。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一个标准的 BasicBlock 通常包含两条路径\n",
    "\n",
    "1. 主路 (Main Path)：这是学习“残差” F(x) 的部分。在 ResNet-18 中，它由两个 3x3 的卷积层构成。\n",
    "Conv2d: 3-1 (3x3 卷积)-->BatchNorm2d: 3-2 (批归一化)-->ReLU: 3-3 (激活函数)-->Conv2d: 3-4 (3x3 卷积)-->BatchNorm2d: 3-5 (批归一化)\n",
    "\n",
    "2. 捷径 (Shortcut Path)：这就是 + x 的部分，直接将输入 x 传递过来。\n",
    "\n",
    "最后，将主路的输出和捷径的输出按元素相加，再经过一个 ReLU 激活函数，得到整个 BasicBlock 的最终输出。"
   ]
  },
  {
   "attachments": {
    "image-2.png": {
     "image/png": "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"
    },
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)\n",
    "\n",
    "![image-2.png](attachment:image-2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cbam的放置位置"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们知道，加载预训练模型的时候，需要加载好预训练的模型架构，然后加载预训练的权重。如果修改模型的架构，比如在中间插入某个模块或层，很可能导致他后续预训练的权重失效。那么如何解决这个问题呢？\n",
    "\n",
    "一种很容易被想到的思想是：cbam可以放置在全连接层之前，这是最简单的想法。保留了原始的信息。可以理解为在模型做出最终分类决策之前，对提取到的最高阶特征图做一次最后的“精炼”和“校准”。\n",
    "\n",
    "但是这么做有一个弊端，注意力机制只在最后起作用，无法帮助网络在中间层构建出更好的、带有注意力信息的特征。前面的所有卷积块依然是“盲目”地提取特征。这就像一个学生直到做完整张试卷才开始划重点，而不是每做完一道题就总结一次。\n",
    "\n",
    "但是你要注意，最后的卷积形式是 卷积--激活--池化--全连接，如果你放置前全连接前的话，cbam中的空间注意力会完全失效，因为此时空间维度不存在了，失去了寻找空间相关性的能力。只留下通道注意力仍然在作用。\n"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实际上，被公认为正确的做法是，在每一个残差块的输出上应用CBAM注意力。你可能会想，这样不是会影响后续的输出，尤其最开始注意力权重交叉的话，很可能导致后续预训练层的权重没有价值了。\n",
    "\n",
    "实际，CBAM模块自身的结构——初始状态接近“直通”，这是最核心的技术原因导致可以采用这个结构。CBAM模块的最终操作是：return x * self.sigmoid(attention)。这里的 x 是原始特征；attention 是学到的注意力图。\n",
    "\n",
    "1. 初始状态分析：在一个模块被随机初始化（还未开始训练）时，其内部的卷积层和全连接层的权重都非常小，接近于0。因此，计算出的 attention 图的值也都会非常接近0。\n",
    "2. Sigmoid函数的特性：当输入为0时，sigmoid(0) 的输出是 0.5。这意味着在训练刚开始的第一步，CBAM模块的操作近似于 x * 0.5。它并没有用一个完全随机的、混乱的特征图去替换原始特征 x。它只是将原始特征 x 按比例缩小了一半。\n",
    "\n",
    "缩小0.5只是对特征数值尺度的缩放，它完整地保留了原始特征图中的空间结构和相对关系。下游的预训练层接收到的不再是“垃圾”，而是一个信号稍弱但结构完好的原始特征。这为后续的学习提供了一个非常稳定的起点。\n",
    "\n",
    "如果CBAM无用：网络可以通过学习，让 attention 图的值都趋近于一个常数，相当于一个固定的缩放。在更理想的情况下，如果能让 attention 图的值都趋近于 sigmoid 函数的反函数中对应输出为1的值，那么CBAM就近似于一个“直通车”(x * 1 = x)，网络可以选择“忽略”它。\n",
    "\n",
    "如果CBAM有用：网络会迅速学会调整权重，让 attention 图中重要的地方值接近1，不重要的地方值接近0，从而实现特征的增强。\n",
    "\n",
    "所以完全可以在不破坏其核心结构的情况下，将CBAM模块无缝地“注入”到预训练的ResNet中。这样做的逻辑是：\n",
    "\n",
    "1. 保留原始结构：原始的残差块负责提取核心特征。\n",
    "2. 增强特征：紧随其后的CBAM模块对这些提取出的特征进行“精炼”，告诉模型应该“关注什么”（what - 通道注意力）和“在哪里关注”（where - 空间注意力）。\n",
    "3. 不破坏预训练权重：原始残差块的预训练权重得以完整保留，我们只是在其后增加了一个新的、需要从头学习的模块。\n",
    "\n",
    "\n",
    "![image.png](attachment:image.png)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torchvision import models\n",
    "\n",
    "# 自定义ResNet18模型，插入CBAM模块\n",
    "class ResNet18_CBAM(nn.Module):\n",
    "    def __init__(self, num_classes=10, pretrained=True, cbam_ratio=16, cbam_kernel=7):\n",
    "        super().__init__()\n",
    "        # 加载预训练ResNet18\n",
    "        self.backbone = models.resnet18(pretrained=pretrained) \n",
    "        \n",
    "        # 修改首层卷积以适应32x32输入（CIFAR10）\n",
    "        self.backbone.conv1 = nn.Conv2d(\n",
    "            in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1, bias=False\n",
    "        )\n",
    "        self.backbone.maxpool = nn.Identity()  # 移除原始MaxPool层（因输入尺寸小）\n",
    "        \n",
    "        # 在每个残差块组后添加CBAM模块\n",
    "        self.cbam_layer1 = CBAM(in_channels=64, ratio=cbam_ratio, kernel_size=cbam_kernel)\n",
    "        self.cbam_layer2 = CBAM(in_channels=128, ratio=cbam_ratio, kernel_size=cbam_kernel)\n",
    "        self.cbam_layer3 = CBAM(in_channels=256, ratio=cbam_ratio, kernel_size=cbam_kernel)\n",
    "        self.cbam_layer4 = CBAM(in_channels=512, ratio=cbam_ratio, kernel_size=cbam_kernel)\n",
    "        \n",
    "        # 修改分类头\n",
    "        self.backbone.fc = nn.Linear(in_features=512, out_features=num_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # 主干特征提取\n",
    "        x = self.backbone.conv1(x)\n",
    "        x = self.backbone.bn1(x)\n",
    "        x = self.backbone.relu(x)  # [B, 64, 32, 32]\n",
    "        \n",
    "        # 第一层残差块 + CBAM\n",
    "        x = self.backbone.layer1(x)  # [B, 64, 32, 32]\n",
    "        x = self.cbam_layer1(x)\n",
    "        \n",
    "        # 第二层残差块 + CBAM\n",
    "        x = self.backbone.layer2(x)  # [B, 128, 16, 16]\n",
    "        x = self.cbam_layer2(x)\n",
    "        \n",
    "        # 第三层残差块 + CBAM\n",
    "        x = self.backbone.layer3(x)  # [B, 256, 8, 8]\n",
    "        x = self.cbam_layer3(x)\n",
    "        \n",
    "        # 第四层残差块 + CBAM\n",
    "        x = self.backbone.layer4(x)  # [B, 512, 4, 4]\n",
    "        x = self.cbam_layer4(x)\n",
    "        \n",
    "        # 全局平均池化 + 分类\n",
    "        x = self.backbone.avgpool(x)  # [B, 512, 1, 1]\n",
    "        x = torch.flatten(x, 1)  # [B, 512]\n",
    "        x = self.backbone.fc(x)  # [B, 10]\n",
    "        return x\n",
    "    \n",
    "# 初始化模型并移至设备\n",
    "model = ResNet18_CBAM().to(device)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
    "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', patience=3, factor=0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练策略"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "差异化学习率\n",
    "\n",
    "预训练层（ResNet部分）：他们是经验丰富的资深专家。他们已经很懂得如何处理特征，不需要大的改动。\n",
    "新模块（CBAM和分类头）：他们是刚入职的实习生，一张白纸，需要快速学习。\n",
    "你的训练策略（优化器）就像是CEO，你会这样分配任务：\n",
    "\n",
    "给实习生（新模块） 设置一个较高的学习率（比如1e-3），让他们快速试错，快速成长。\n",
    "给专家（预训练层） 设置一个极低的学习率（比如1e-5），告诉他们：“你们基本保持现状，只需要根据实习生的表现做一些微小的调整即可。”\n",
    "\n",
    "\n",
    "这里我们介绍一种比较适合这里的预训练策略：\n",
    "1. 阶段 1（epoch 1-5）：\n",
    "仅解冻分类头（fc）和所有 CBAM 模块，冻结 ResNet18 的主干卷积层（layer1-4）。\n",
    "目标：先让模型通过预训练特征学习新任务的分类边界，同时微调注意力模块。\n",
    "学习率：1e-3（较高学习率加速分类头收敛）。\n",
    "阶段 2（epoch 6-20）：\n",
    "解冻高层卷积层（layer3、layer4）+ 分类头 + CBAM，冻结低层卷积层（layer1、layer2）。\n",
    "目标：释放高层语义特征（如 “物体类别” 相关层），适应新任务的抽象表示。\n",
    "学习率：1e-4（降低学习率，避免破坏预训练权重）。\n",
    "阶段 3（epoch 21-50）：\n",
    "解冻所有层（包括低层卷积层 layer1、layer2），端到端微调。\n",
    "目标：让底层特征（如边缘、纹理）与新任务对齐，提升特征表达能力。\n",
    "学习率：1e-5（最小学习率，缓慢调整全局参数）。\n",
    "2. CBAM 模块集成\n",
    "在每个残差块组（layer1-4）输出后添加 CBAM，确保注意力机制作用于各阶段特征图，且不影响残差块内部的跳连接。\n",
    "CBAM 参数默认使用ratio=16和kernel_size=7，可根据计算资源调整（如减小ratio以降低参数量）。\n",
    "3. 学习率与优化器\n",
    "使用Adam优化器，分阶段手动调整学习率（也可配合自动调度器如CosineAnnealingLR）。\n",
    "每次解冻新层时，学习率降低一个数量级，避免梯度冲击预训练权重。\n",
    "预期效果与监控\n",
    "阶段 1：测试准确率应逐步提升至 20%-40%（摆脱随机猜测），损失开始下降。\n",
    "阶段 2：准确率加速提升（利用高层特征），可能达到 60%-80%。\n",
    "阶段 3：准确率缓慢提升并收敛（底层特征微调），最终可能超过 85%（取决于 CIFAR10 的基线表现）。\n",
    "监控重点：\n",
    "若阶段 1 准确率仍为 9%，检查数据预处理或标签是否正确。\n",
    "若阶段 2 后准确率停滞，尝试增加正则化（如在 CBAM 后添加 Dropout）或调整 CBAM 参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "在训练这里，我们采用2种训练策略\n",
    "\n",
    "### 差异化学习率\n",
    "\n",
    "把我们的模型想象成一个公司团队来执行新项目 (CIFAR-10 分类任务):\n",
    "- **预训练层 (ResNet 部分)**：他们是经验丰富的**资深专家**。他们已经很懂得如何处理通用图像特征，不需要大的改动。\n",
    "- **新模块 (CBAM 和分类头)**：他们是刚入职的**实习生**，对新任务一无所知，需要快速学习和试错。\n",
    "\n",
    "作为 CEO，我们的训练策略是：\n",
    "- 给 **实习生** 设置一个**较高的学习率** (例如 `1e-3`)，让他们快速成长。\n",
    "- 给 **专家** 设置一个**极低的学习率** (例如 `1e-5`)，告诉他们：“保持现状，根据实习生的表现稍作微调即可。”\n",
    "\n",
    "### 三阶段式解冻与微调 (Progressive Unfreezing)\n",
    "\n",
    "**1. 阶段一 (Epoch 1-5): 预热“实习生”**\n",
    "   - **解冻部分**: 仅解冻分类头 (`fc`) 和所有 `CBAM` 模块。\n",
    "   - **冻结部分**: 冻结 ResNet18 的所有主干卷积层 (`conv1`, `bn1`, `layer1` 至 `layer4`)。\n",
    "   - **目标**: 先利用强大的预训练特征，让模型快速学习新任务的分类边界，同时让注意力模块找到初步的关注点。\n",
    "   - **学习率**: `1e-3` (使用较高学习率加速收敛)。\n",
    "\n",
    "**2. 阶段二 (Epoch 6-20): 唤醒“高层专家”**\n",
    "   - **解冻部分**: 在上一阶段的基础上，额外解冻高层语义相关的卷积层 (`layer3`, `layer4`)。\n",
    "   - **冻结部分**: 底层特征提取层 (`conv1`, `bn1`, `layer1`, `layer2`) 仍然冻结。\n",
    "   - **目标**: 释放模型的高层特征提取能力，使其适应新任务的抽象概念 (例如“鸟的轮廓”比“一条边”更抽象)。\n",
    "   - **学习率**: `1e-4` (降低学习率，避免新解冻的层因梯度过大而破坏其宝贵的预训练权重)。\n",
    "\n",
    "**3. 阶段三 (Epoch 21-50): 全员协同微调**\n",
    "   - **解冻部分**: 解冻模型的所有层，进行端到端微调。\n",
    "   - **冻结部分**: 无。\n",
    "   - **目标**: 让模型的底层特征 (如边缘、纹理) 也与新任务进行对齐，做最后的精细化调整，提升整体性能。\n",
    "   - **学习率**: `1e-5` (使用最低的学习率，在整个模型上缓慢、稳定地进行全局优化)。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "在深度神经网络中，我们通常这样描述信息流：\n",
    "* 靠近输入图像的层，称为“**底层**”或“**浅层**”。\n",
    "* 靠近最终输出（分类头）的层，称为“**高层**”或“**深层**”。\n",
    "\n",
    "所以，**“解冻高层卷积”** 指的就是解冻`layer3`和`layer4`这两组残差块。\n",
    "\n",
    "\n",
    "\n",
    "为了更直观，我们可以把ResNet18的结构想象成一个处理流水线：\n",
    "\n",
    "`输入图像` -> `[预处理层 conv1, bn1, relu]` -> `[layer1]` -> `[layer2]` -> `[layer3]` -> `[layer4]` -> `[分类头 avgpool, fc]` -> `输出结果`\n",
    "\n",
    "ResNet18有 **4 组**核心的残差块，即`layer1`, `layer2`, `layer3`, `layer4`。每一组`layer`内部又包含2个`BasicBlock`（每个`BasicBlock`包含2个卷积层）。\n",
    "\n",
    "在阶段2，我们解冻的是 **`layer3`** 和 **`layer4`** 这两组。同时，`CBAM`模块和`fc`层保持解冻状态。而`layer1`和`layer2`以及最开始的`conv1`则继续保持冻结。\n",
    "\n",
    "为什么解冻后面（高层）而不解冻前面（底层）？\n",
    "\n",
    "这是整个迁移学习和微调策略的精髓所在，核心原因在于**不同层级的卷积层学习到的特征类型是不同的**。\n",
    "\n",
    "我们可以用一个生动的比喻来理解：**把神经网络学习的过程看作一位画家画画。**\n",
    "\n",
    "**底层网络 (layer1, layer2) —— 学习“笔触和纹理”**\n",
    "\n",
    "* **学习内容**：这些靠近输入的层，学习的是非常**通用、基础**的视觉元素。就像画家首先要学会如何画出**直线、曲线、点、色彩块、明暗渐变、材质纹理（毛发、金属）**一样。\n",
    "* **任务相关性**：这些特征是**高度可复用**的。无论你画的是猫、是汽车、还是房子，构成它们的基本笔触和纹理都是一样的。同理，无论是ImageNet中的图片，还是CIFAR-10中的图片，它们都由这些基础视觉元素构成。\n",
    "* **微调策略**：因为这些知识非常宝贵且通用，我们**不希望轻易改动它**。过早地用少量新数据（CIFAR-10）去训练它们，反而可能破坏（“污染”）这些已经学得很好的通用知识。所以，在微调初期，我们选择**冻结它们**。\n",
    "\n",
    "**高层网络 (layer3, layer4) —— 学习“构图和概念”**\n",
    "\n",
    "* **学习内容**：这些靠近输出的层，负责将底层学到的基础元素**组合成更复杂、更具语义**的部件或概念。就像画家把线条和色块组合成**“眼睛”、“车轮”、“屋顶”**，并最终形成**“一张猫脸”、“一辆汽车的侧面”**这样的整体概念。\n",
    "* **任务相关性**：这些组合方式和最终概念与**具体任务高度相关**。例如，在ImageNet上，模型可能学会了将“圆形”和“网格”组合成“篮球”；但在CIFAR-10上，它需要学习将“圆形”和“金属光泽”组合成“汽车轮胎”。这种高层抽象知识需要针对新任务进行调整。\n",
    "* **微调策略**：因为这部分知识最具有“任务特异性”，所以它们是**最需要被重新训练和调整**的。解冻`layer3`和`layer4`，就是为了让模型能够利用已经学好的基础特征，去学习如何为我们的新任务（CIFAR-10分类）构建新的、专属的物体概念。\n",
    "\n",
    "总结表格\n",
    "\n",
    "| 层级 (Layer Level) | 对应层 (Corresponding Layers) | 学习特征 (Learned Features) | 任务相关性 | 微调策略 |\n",
    "| :--- | :--- | :--- | :--- | :--- |\n",
    "| **底层 (Low-Level)** | `conv1`, `layer1`, `layer2` | 边缘、颜色、纹理、方向等**通用基础特征** | 低 (Universal) | **后期解冻或保持冻结** (保护通用知识) |\n",
    "| **高层 (High-Level)** | `layer3`, `layer4` | 物体部件、复杂形状、**特定物体的概念** | 高 (Task-Specific) | **优先解冻** (适应新任务) |\n",
    "\n",
    "因此，**“先解冻高层，后解冻底层”** 的策略，是一种非常高效且稳健的微调方法，它最大限度地保留了预训练模型的泛化能力，同时又能精确地让模型适应新任务的特定需求。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始使用带分阶段微调策略的ResNet18+CBAM模型进行训练...\n",
      "\n",
      "==================================================\n",
      "🚀 **阶段 1：训练注意力模块和分类头**\n",
      "==================================================\n",
      "\n",
      "---> 解冻以下部分并设为可训练: ['cbam', 'backbone.fc']\n",
      "Epoch: 1/50 | Batch: 100/782 | 单Batch损失: 1.7485 | 累计平均损失: 2.0810\n",
      "Epoch: 1/50 | Batch: 200/782 | 单Batch损失: 1.6740 | 累计平均损失: 1.9501\n",
      "Epoch: 1/50 | Batch: 300/782 | 单Batch损失: 1.9060 | 累计平均损失: 1.8818\n",
      "Epoch: 1/50 | Batch: 400/782 | 单Batch损失: 1.7339 | 累计平均损失: 1.8351\n",
      "Epoch: 1/50 | Batch: 500/782 | 单Batch损失: 1.4724 | 累计平均损失: 1.8033\n",
      "Epoch: 1/50 | Batch: 600/782 | 单Batch损失: 1.5032 | 累计平均损失: 1.7749\n",
      "Epoch: 1/50 | Batch: 700/782 | 单Batch损失: 1.4728 | 累计平均损失: 1.7500\n",
      "Epoch 1/50 完成 | 耗时: 34.61s | 训练准确率: 37.31% | 测试准确率: 47.48%\n",
      "Epoch: 2/50 | Batch: 100/782 | 单Batch损失: 1.7628 | 累计平均损失: 1.5714\n",
      "Epoch: 2/50 | Batch: 200/782 | 单Batch损失: 1.9257 | 累计平均损失: 1.5662\n",
      "Epoch: 2/50 | Batch: 300/782 | 单Batch损失: 1.5004 | 累计平均损失: 1.5616\n",
      "Epoch: 2/50 | Batch: 400/782 | 单Batch损失: 1.4699 | 累计平均损失: 1.5525\n",
      "Epoch: 2/50 | Batch: 500/782 | 单Batch损失: 1.4514 | 累计平均损失: 1.5514\n",
      "Epoch: 2/50 | Batch: 600/782 | 单Batch损失: 1.3356 | 累计平均损失: 1.5455\n",
      "Epoch: 2/50 | Batch: 700/782 | 单Batch损失: 1.5402 | 累计平均损失: 1.5433\n",
      "Epoch 2/50 完成 | 耗时: 34.17s | 训练准确率: 45.00% | 测试准确率: 49.78%\n",
      "Epoch: 3/50 | Batch: 100/782 | 单Batch损失: 1.5248 | 累计平均损失: 1.4952\n",
      "Epoch: 3/50 | Batch: 200/782 | 单Batch损失: 1.3679 | 累计平均损失: 1.5002\n",
      "Epoch: 3/50 | Batch: 300/782 | 单Batch损失: 1.5566 | 累计平均损失: 1.4931\n",
      "Epoch: 3/50 | Batch: 400/782 | 单Batch损失: 1.3878 | 累计平均损失: 1.4883\n",
      "Epoch: 3/50 | Batch: 500/782 | 单Batch损失: 1.4720 | 累计平均损失: 1.4824\n",
      "Epoch: 3/50 | Batch: 600/782 | 单Batch损失: 1.2727 | 累计平均损失: 1.4808\n",
      "Epoch: 3/50 | Batch: 700/782 | 单Batch损失: 1.5683 | 累计平均损失: 1.4790\n",
      "Epoch 3/50 完成 | 耗时: 33.76s | 训练准确率: 47.11% | 测试准确率: 53.26%\n",
      "Epoch: 4/50 | Batch: 100/782 | 单Batch损失: 1.6395 | 累计平均损失: 1.4641\n",
      "Epoch: 4/50 | Batch: 200/782 | 单Batch损失: 1.4799 | 累计平均损失: 1.4411\n",
      "Epoch: 4/50 | Batch: 300/782 | 单Batch损失: 1.8871 | 累计平均损失: 1.4465\n",
      "Epoch: 4/50 | Batch: 400/782 | 单Batch损失: 1.6204 | 累计平均损失: 1.4413\n",
      "Epoch: 4/50 | Batch: 500/782 | 单Batch损失: 1.4945 | 累计平均损失: 1.4390\n",
      "Epoch: 4/50 | Batch: 600/782 | 单Batch损失: 1.5670 | 累计平均损失: 1.4385\n",
      "Epoch: 4/50 | Batch: 700/782 | 单Batch损失: 1.5015 | 累计平均损失: 1.4388\n",
      "Epoch 4/50 完成 | 耗时: 33.73s | 训练准确率: 48.73% | 测试准确率: 54.52%\n",
      "Epoch: 5/50 | Batch: 100/782 | 单Batch损失: 1.3727 | 累计平均损失: 1.4345\n",
      "Epoch: 5/50 | Batch: 200/782 | 单Batch损失: 1.4323 | 累计平均损失: 1.4247\n",
      "Epoch: 5/50 | Batch: 300/782 | 单Batch损失: 1.3007 | 累计平均损失: 1.4216\n",
      "Epoch: 5/50 | Batch: 400/782 | 单Batch损失: 1.4333 | 累计平均损失: 1.4169\n",
      "Epoch: 5/50 | Batch: 500/782 | 单Batch损失: 1.5552 | 累计平均损失: 1.4156\n",
      "Epoch: 5/50 | Batch: 600/782 | 单Batch损失: 1.3340 | 累计平均损失: 1.4127\n",
      "Epoch: 5/50 | Batch: 700/782 | 单Batch损失: 1.5470 | 累计平均损失: 1.4127\n",
      "Epoch 5/50 完成 | 耗时: 34.30s | 训练准确率: 49.86% | 测试准确率: 54.98%\n",
      "\n",
      "==================================================\n",
      "✈️ **阶段 2：解冻高层卷积层 (layer3, layer4)**\n",
      "==================================================\n",
      "\n",
      "---> 解冻以下部分并设为可训练: ['cbam', 'backbone.fc', 'backbone.layer3', 'backbone.layer4']\n",
      "Epoch: 6/50 | Batch: 100/782 | 单Batch损失: 0.9357 | 累计平均损失: 1.3187\n",
      "Epoch: 6/50 | Batch: 200/782 | 单Batch损失: 1.1615 | 累计平均损失: 1.2733\n",
      "Epoch: 6/50 | Batch: 300/782 | 单Batch损失: 1.0210 | 累计平均损失: 1.2362\n",
      "Epoch: 6/50 | Batch: 400/782 | 单Batch损失: 1.0903 | 累计平均损失: 1.1955\n",
      "Epoch: 6/50 | Batch: 500/782 | 单Batch损失: 1.0774 | 累计平均损失: 1.1670\n",
      "Epoch: 6/50 | Batch: 600/782 | 单Batch损失: 1.0801 | 累计平均损失: 1.1424\n",
      "Epoch: 6/50 | Batch: 700/782 | 单Batch损失: 0.8669 | 累计平均损失: 1.1204\n",
      "Epoch 6/50 完成 | 耗时: 39.74s | 训练准确率: 61.34% | 测试准确率: 71.71%\n",
      "Epoch: 7/50 | Batch: 100/782 | 单Batch损失: 0.9683 | 累计平均损失: 0.9085\n",
      "Epoch: 7/50 | Batch: 200/782 | 单Batch损失: 0.8463 | 累计平均损失: 0.9039\n",
      "Epoch: 7/50 | Batch: 300/782 | 单Batch损失: 0.9273 | 累计平均损失: 0.8993\n",
      "Epoch: 7/50 | Batch: 400/782 | 单Batch损失: 0.7971 | 累计平均损失: 0.8936\n",
      "Epoch: 7/50 | Batch: 500/782 | 单Batch损失: 0.8922 | 累计平均损失: 0.8871\n",
      "Epoch: 7/50 | Batch: 600/782 | 单Batch损失: 0.9347 | 累计平均损失: 0.8812\n",
      "Epoch: 7/50 | Batch: 700/782 | 单Batch损失: 0.9257 | 累计平均损失: 0.8737\n",
      "Epoch 7/50 完成 | 耗时: 38.53s | 训练准确率: 69.63% | 测试准确率: 76.12%\n",
      "Epoch: 8/50 | Batch: 100/782 | 单Batch损失: 0.7948 | 累计平均损失: 0.7646\n",
      "Epoch: 8/50 | Batch: 200/782 | 单Batch损失: 0.9495 | 累计平均损失: 0.7734\n",
      "Epoch: 8/50 | Batch: 300/782 | 单Batch损失: 0.8315 | 累计平均损失: 0.7782\n",
      "Epoch: 8/50 | Batch: 400/782 | 单Batch损失: 0.9908 | 累计平均损失: 0.7694\n",
      "Epoch: 8/50 | Batch: 500/782 | 单Batch损失: 0.7027 | 累计平均损失: 0.7675\n",
      "Epoch: 8/50 | Batch: 600/782 | 单Batch损失: 0.8308 | 累计平均损失: 0.7613\n",
      "Epoch: 8/50 | Batch: 700/782 | 单Batch损失: 0.6263 | 累计平均损失: 0.7589\n",
      "Epoch 8/50 完成 | 耗时: 38.28s | 训练准确率: 73.49% | 测试准确率: 79.02%\n",
      "Epoch: 9/50 | Batch: 100/782 | 单Batch损失: 0.7367 | 累计平均损失: 0.6974\n",
      "Epoch: 9/50 | Batch: 200/782 | 单Batch损失: 0.6866 | 累计平均损失: 0.6948\n",
      "Epoch: 9/50 | Batch: 300/782 | 单Batch损失: 0.6135 | 累计平均损失: 0.6950\n",
      "Epoch: 9/50 | Batch: 400/782 | 单Batch损失: 0.6402 | 累计平均损失: 0.6934\n",
      "Epoch: 9/50 | Batch: 500/782 | 单Batch损失: 0.7229 | 累计平均损失: 0.6906\n",
      "Epoch: 9/50 | Batch: 600/782 | 单Batch损失: 0.7312 | 累计平均损失: 0.6886\n",
      "Epoch: 9/50 | Batch: 700/782 | 单Batch损失: 0.7411 | 累计平均损失: 0.6887\n",
      "Epoch 9/50 完成 | 耗时: 38.31s | 训练准确率: 75.77% | 测试准确率: 80.50%\n",
      "Epoch: 10/50 | Batch: 100/782 | 单Batch损失: 0.5954 | 累计平均损失: 0.6497\n",
      "Epoch: 10/50 | Batch: 200/782 | 单Batch损失: 0.8176 | 累计平均损失: 0.6408\n",
      "Epoch: 10/50 | Batch: 300/782 | 单Batch损失: 0.6548 | 累计平均损失: 0.6400\n",
      "Epoch: 10/50 | Batch: 400/782 | 单Batch损失: 0.8509 | 累计平均损失: 0.6427\n",
      "Epoch: 10/50 | Batch: 500/782 | 单Batch损失: 0.4540 | 累计平均损失: 0.6384\n",
      "Epoch: 10/50 | Batch: 600/782 | 单Batch损失: 0.7101 | 累计平均损失: 0.6378\n",
      "Epoch: 10/50 | Batch: 700/782 | 单Batch损失: 0.9033 | 累计平均损失: 0.6382\n",
      "Epoch 10/50 完成 | 耗时: 38.01s | 训练准确率: 77.85% | 测试准确率: 82.01%\n",
      "Epoch: 11/50 | Batch: 100/782 | 单Batch损失: 0.5891 | 累计平均损失: 0.5997\n",
      "Epoch: 11/50 | Batch: 200/782 | 单Batch损失: 0.5143 | 累计平均损失: 0.5899\n",
      "Epoch: 11/50 | Batch: 300/782 | 单Batch损失: 0.6023 | 累计平均损失: 0.5968\n",
      "Epoch: 11/50 | Batch: 400/782 | 单Batch损失: 0.7850 | 累计平均损失: 0.5965\n",
      "Epoch: 11/50 | Batch: 500/782 | 单Batch损失: 0.5071 | 累计平均损失: 0.5975\n",
      "Epoch: 11/50 | Batch: 600/782 | 单Batch损失: 0.7549 | 累计平均损失: 0.5962\n",
      "Epoch: 11/50 | Batch: 700/782 | 单Batch损失: 0.6783 | 累计平均损失: 0.5990\n",
      "Epoch 11/50 完成 | 耗时: 38.33s | 训练准确率: 79.08% | 测试准确率: 82.30%\n",
      "Epoch: 12/50 | Batch: 100/782 | 单Batch损失: 0.7179 | 累计平均损失: 0.5464\n",
      "Epoch: 12/50 | Batch: 200/782 | 单Batch损失: 0.5231 | 累计平均损失: 0.5545\n",
      "Epoch: 12/50 | Batch: 300/782 | 单Batch损失: 0.5699 | 累计平均损失: 0.5565\n",
      "Epoch: 12/50 | Batch: 400/782 | 单Batch损失: 0.6491 | 累计平均损失: 0.5634\n",
      "Epoch: 12/50 | Batch: 500/782 | 单Batch损失: 0.6913 | 累计平均损失: 0.5609\n",
      "Epoch: 12/50 | Batch: 600/782 | 单Batch损失: 0.4590 | 累计平均损失: 0.5624\n",
      "Epoch: 12/50 | Batch: 700/782 | 单Batch损失: 0.6569 | 累计平均损失: 0.5604\n",
      "Epoch 12/50 完成 | 耗时: 39.76s | 训练准确率: 80.36% | 测试准确率: 83.65%\n",
      "Epoch: 13/50 | Batch: 100/782 | 单Batch损失: 0.6940 | 累计平均损失: 0.5201\n",
      "Epoch: 13/50 | Batch: 200/782 | 单Batch损失: 0.4849 | 累计平均损失: 0.5252\n",
      "Epoch: 13/50 | Batch: 300/782 | 单Batch损失: 0.6628 | 累计平均损失: 0.5222\n",
      "Epoch: 13/50 | Batch: 400/782 | 单Batch损失: 0.3912 | 累计平均损失: 0.5183\n",
      "Epoch: 13/50 | Batch: 500/782 | 单Batch损失: 0.5542 | 累计平均损失: 0.5212\n",
      "Epoch: 13/50 | Batch: 600/782 | 单Batch损失: 0.5250 | 累计平均损失: 0.5255\n",
      "Epoch: 13/50 | Batch: 700/782 | 单Batch损失: 0.5008 | 累计平均损失: 0.5268\n",
      "Epoch 13/50 完成 | 耗时: 38.92s | 训练准确率: 81.54% | 测试准确率: 83.06%\n",
      "Epoch: 14/50 | Batch: 100/782 | 单Batch损失: 0.4900 | 累计平均损失: 0.5081\n",
      "Epoch: 14/50 | Batch: 200/782 | 单Batch损失: 0.2449 | 累计平均损失: 0.5015\n",
      "Epoch: 14/50 | Batch: 300/782 | 单Batch损失: 0.5278 | 累计平均损失: 0.5077\n",
      "Epoch: 14/50 | Batch: 400/782 | 单Batch损失: 0.4552 | 累计平均损失: 0.5091\n",
      "Epoch: 14/50 | Batch: 500/782 | 单Batch损失: 0.5959 | 累计平均损失: 0.5089\n",
      "Epoch: 14/50 | Batch: 600/782 | 单Batch损失: 0.5395 | 累计平均损失: 0.5061\n",
      "Epoch: 14/50 | Batch: 700/782 | 单Batch损失: 0.3625 | 累计平均损失: 0.5046\n",
      "Epoch 14/50 完成 | 耗时: 38.74s | 训练准确率: 82.38% | 测试准确率: 84.87%\n",
      "Epoch: 15/50 | Batch: 100/782 | 单Batch损失: 0.4743 | 累计平均损失: 0.4653\n",
      "Epoch: 15/50 | Batch: 200/782 | 单Batch损失: 0.5508 | 累计平均损失: 0.4706\n",
      "Epoch: 15/50 | Batch: 300/782 | 单Batch损失: 0.4525 | 累计平均损失: 0.4768\n",
      "Epoch: 15/50 | Batch: 400/782 | 单Batch损失: 0.3632 | 累计平均损失: 0.4771\n",
      "Epoch: 15/50 | Batch: 500/782 | 单Batch损失: 0.4805 | 累计平均损失: 0.4752\n",
      "Epoch: 15/50 | Batch: 600/782 | 单Batch损失: 0.3743 | 累计平均损失: 0.4752\n",
      "Epoch: 15/50 | Batch: 700/782 | 单Batch损失: 0.4114 | 累计平均损失: 0.4780\n",
      "Epoch 15/50 完成 | 耗时: 38.82s | 训练准确率: 83.15% | 测试准确率: 84.70%\n",
      "Epoch: 16/50 | Batch: 100/782 | 单Batch损失: 0.5127 | 累计平均损失: 0.4535\n",
      "Epoch: 16/50 | Batch: 200/782 | 单Batch损失: 0.4509 | 累计平均损失: 0.4563\n",
      "Epoch: 16/50 | Batch: 300/782 | 单Batch损失: 0.5747 | 累计平均损失: 0.4581\n",
      "Epoch: 16/50 | Batch: 400/782 | 单Batch损失: 0.4282 | 累计平均损失: 0.4567\n",
      "Epoch: 16/50 | Batch: 500/782 | 单Batch损失: 0.4157 | 累计平均损失: 0.4546\n",
      "Epoch: 16/50 | Batch: 600/782 | 单Batch损失: 0.4103 | 累计平均损失: 0.4545\n",
      "Epoch: 16/50 | Batch: 700/782 | 单Batch损失: 0.4214 | 累计平均损失: 0.4552\n",
      "Epoch 16/50 完成 | 耗时: 38.26s | 训练准确率: 84.01% | 测试准确率: 85.25%\n",
      "Epoch: 17/50 | Batch: 100/782 | 单Batch损失: 0.3618 | 累计平均损失: 0.4283\n",
      "Epoch: 17/50 | Batch: 200/782 | 单Batch损失: 0.2550 | 累计平均损失: 0.4222\n",
      "Epoch: 17/50 | Batch: 300/782 | 单Batch损失: 0.4324 | 累计平均损失: 0.4275\n",
      "Epoch: 17/50 | Batch: 400/782 | 单Batch损失: 0.1891 | 累计平均损失: 0.4301\n",
      "Epoch: 17/50 | Batch: 500/782 | 单Batch损失: 0.3567 | 累计平均损失: 0.4339\n",
      "Epoch: 17/50 | Batch: 600/782 | 单Batch损失: 0.3672 | 累计平均损失: 0.4344\n",
      "Epoch: 17/50 | Batch: 700/782 | 单Batch损失: 0.3693 | 累计平均损失: 0.4373\n",
      "Epoch 17/50 完成 | 耗时: 38.21s | 训练准确率: 84.50% | 测试准确率: 85.57%\n",
      "Epoch: 18/50 | Batch: 100/782 | 单Batch损失: 0.2888 | 累计平均损失: 0.4294\n",
      "Epoch: 18/50 | Batch: 200/782 | 单Batch损失: 0.4332 | 累计平均损失: 0.4249\n",
      "Epoch: 18/50 | Batch: 300/782 | 单Batch损失: 0.4769 | 累计平均损失: 0.4212\n",
      "Epoch: 18/50 | Batch: 400/782 | 单Batch损失: 0.4411 | 累计平均损失: 0.4228\n",
      "Epoch: 18/50 | Batch: 500/782 | 单Batch损失: 0.3433 | 累计平均损失: 0.4190\n",
      "Epoch: 18/50 | Batch: 600/782 | 单Batch损失: 0.3476 | 累计平均损失: 0.4196\n",
      "Epoch: 18/50 | Batch: 700/782 | 单Batch损失: 0.5196 | 累计平均损失: 0.4220\n",
      "Epoch 18/50 完成 | 耗时: 38.76s | 训练准确率: 85.19% | 测试准确率: 85.74%\n",
      "Epoch: 19/50 | Batch: 100/782 | 单Batch损失: 0.4203 | 累计平均损失: 0.4041\n",
      "Epoch: 19/50 | Batch: 200/782 | 单Batch损失: 0.3616 | 累计平均损失: 0.4021\n",
      "Epoch: 19/50 | Batch: 300/782 | 单Batch损失: 0.5229 | 累计平均损失: 0.4017\n",
      "Epoch: 19/50 | Batch: 400/782 | 单Batch损失: 0.3150 | 累计平均损失: 0.3999\n",
      "Epoch: 19/50 | Batch: 500/782 | 单Batch损失: 0.4656 | 累计平均损失: 0.3961\n",
      "Epoch: 19/50 | Batch: 600/782 | 单Batch损失: 0.4970 | 累计平均损失: 0.3980\n",
      "Epoch: 19/50 | Batch: 700/782 | 单Batch损失: 0.4652 | 累计平均损失: 0.3989\n",
      "Epoch 19/50 完成 | 耗时: 41.85s | 训练准确率: 86.03% | 测试准确率: 85.44%\n",
      "Epoch: 20/50 | Batch: 100/782 | 单Batch损失: 0.4339 | 累计平均损失: 0.3789\n",
      "Epoch: 20/50 | Batch: 200/782 | 单Batch损失: 0.6232 | 累计平均损失: 0.3755\n",
      "Epoch: 20/50 | Batch: 300/782 | 单Batch损失: 0.3095 | 累计平均损失: 0.3820\n",
      "Epoch: 20/50 | Batch: 400/782 | 单Batch损失: 0.2718 | 累计平均损失: 0.3882\n",
      "Epoch: 20/50 | Batch: 500/782 | 单Batch损失: 0.4242 | 累计平均损失: 0.3861\n",
      "Epoch: 20/50 | Batch: 600/782 | 单Batch损失: 0.4585 | 累计平均损失: 0.3873\n",
      "Epoch: 20/50 | Batch: 700/782 | 单Batch损失: 0.4896 | 累计平均损失: 0.3869\n",
      "Epoch 20/50 完成 | 耗时: 38.81s | 训练准确率: 86.26% | 测试准确率: 85.99%\n",
      "\n",
      "==================================================\n",
      "🛰️ **阶段 3：解冻所有层，进行全局微调**\n",
      "==================================================\n",
      "Epoch: 21/50 | Batch: 100/782 | 单Batch损失: 0.4200 | 累计平均损失: 0.3498\n",
      "Epoch: 21/50 | Batch: 200/782 | 单Batch损失: 0.2432 | 累计平均损失: 0.3323\n",
      "Epoch: 21/50 | Batch: 300/782 | 单Batch损失: 0.3133 | 累计平均损失: 0.3310\n",
      "Epoch: 21/50 | Batch: 400/782 | 单Batch损失: 0.4987 | 累计平均损失: 0.3280\n",
      "Epoch: 21/50 | Batch: 500/782 | 单Batch损失: 0.1875 | 累计平均损失: 0.3281\n",
      "Epoch: 21/50 | Batch: 600/782 | 单Batch损失: 0.1709 | 累计平均损失: 0.3234\n",
      "Epoch: 21/50 | Batch: 700/782 | 单Batch损失: 0.2414 | 累计平均损失: 0.3212\n",
      "Epoch 21/50 完成 | 耗时: 48.79s | 训练准确率: 88.75% | 测试准确率: 87.58%\n",
      "Epoch: 22/50 | Batch: 100/782 | 单Batch损失: 0.2785 | 累计平均损失: 0.2874\n",
      "Epoch: 22/50 | Batch: 200/782 | 单Batch损失: 0.3556 | 累计平均损失: 0.2938\n",
      "Epoch: 22/50 | Batch: 300/782 | 单Batch损失: 0.3327 | 累计平均损失: 0.2930\n",
      "Epoch: 22/50 | Batch: 400/782 | 单Batch损失: 0.2000 | 累计平均损失: 0.2898\n",
      "Epoch: 22/50 | Batch: 500/782 | 单Batch损失: 0.1706 | 累计平均损失: 0.2935\n",
      "Epoch: 22/50 | Batch: 600/782 | 单Batch损失: 0.2644 | 累计平均损失: 0.2929\n",
      "Epoch: 22/50 | Batch: 700/782 | 单Batch损失: 0.3852 | 累计平均损失: 0.2933\n",
      "Epoch 22/50 完成 | 耗时: 48.99s | 训练准确率: 89.72% | 测试准确率: 88.06%\n",
      "Epoch: 23/50 | Batch: 100/782 | 单Batch损失: 0.3448 | 累计平均损失: 0.2880\n",
      "Epoch: 23/50 | Batch: 200/782 | 单Batch损失: 0.3574 | 累计平均损失: 0.2777\n",
      "Epoch: 23/50 | Batch: 300/782 | 单Batch损失: 0.1636 | 累计平均损失: 0.2787\n",
      "Epoch: 23/50 | Batch: 400/782 | 单Batch损失: 0.2874 | 累计平均损失: 0.2785\n",
      "Epoch: 23/50 | Batch: 500/782 | 单Batch损失: 0.3345 | 累计平均损失: 0.2763\n",
      "Epoch: 23/50 | Batch: 600/782 | 单Batch损失: 0.2607 | 累计平均损失: 0.2753\n",
      "Epoch: 23/50 | Batch: 700/782 | 单Batch损失: 0.2872 | 累计平均损失: 0.2743\n",
      "Epoch 23/50 完成 | 耗时: 49.06s | 训练准确率: 90.30% | 测试准确率: 88.10%\n",
      "Epoch: 24/50 | Batch: 100/782 | 单Batch损失: 0.2014 | 累计平均损失: 0.2681\n",
      "Epoch: 24/50 | Batch: 200/782 | 单Batch损失: 0.4149 | 累计平均损失: 0.2629\n",
      "Epoch: 24/50 | Batch: 300/782 | 单Batch损失: 0.3364 | 累计平均损失: 0.2594\n",
      "Epoch: 24/50 | Batch: 400/782 | 单Batch损失: 0.4253 | 累计平均损失: 0.2604\n",
      "Epoch: 24/50 | Batch: 500/782 | 单Batch损失: 0.3066 | 累计平均损失: 0.2600\n",
      "Epoch: 24/50 | Batch: 600/782 | 单Batch损失: 0.1681 | 累计平均损失: 0.2593\n",
      "Epoch: 24/50 | Batch: 700/782 | 单Batch损失: 0.3618 | 累计平均损失: 0.2585\n",
      "Epoch 24/50 完成 | 耗时: 48.64s | 训练准确率: 90.96% | 测试准确率: 88.31%\n",
      "Epoch: 25/50 | Batch: 100/782 | 单Batch损失: 0.2214 | 累计平均损失: 0.2511\n",
      "Epoch: 25/50 | Batch: 200/782 | 单Batch损失: 0.2966 | 累计平均损失: 0.2615\n",
      "Epoch: 25/50 | Batch: 300/782 | 单Batch损失: 0.1594 | 累计平均损失: 0.2570\n",
      "Epoch: 25/50 | Batch: 400/782 | 单Batch损失: 0.2951 | 累计平均损失: 0.2499\n",
      "Epoch: 25/50 | Batch: 500/782 | 单Batch损失: 0.1901 | 累计平均损失: 0.2499\n",
      "Epoch: 25/50 | Batch: 600/782 | 单Batch损失: 0.2421 | 累计平均损失: 0.2502\n",
      "Epoch: 25/50 | Batch: 700/782 | 单Batch损失: 0.1874 | 累计平均损失: 0.2486\n",
      "Epoch 25/50 完成 | 耗时: 57.76s | 训练准确率: 91.23% | 测试准确率: 88.42%\n",
      "Epoch: 26/50 | Batch: 100/782 | 单Batch损失: 0.1826 | 累计平均损失: 0.2474\n",
      "Epoch: 26/50 | Batch: 200/782 | 单Batch损失: 0.1973 | 累计平均损失: 0.2447\n",
      "Epoch: 26/50 | Batch: 300/782 | 单Batch损失: 0.2452 | 累计平均损失: 0.2410\n",
      "Epoch: 26/50 | Batch: 400/782 | 单Batch损失: 0.1659 | 累计平均损失: 0.2416\n",
      "Epoch: 26/50 | Batch: 500/782 | 单Batch损失: 0.2407 | 累计平均损失: 0.2397\n",
      "Epoch: 26/50 | Batch: 600/782 | 单Batch损失: 0.2094 | 累计平均损失: 0.2429\n",
      "Epoch: 26/50 | Batch: 700/782 | 单Batch损失: 0.2353 | 累计平均损失: 0.2424\n",
      "Epoch 26/50 完成 | 耗时: 51.15s | 训练准确率: 91.46% | 测试准确率: 88.71%\n",
      "Epoch: 27/50 | Batch: 100/782 | 单Batch损失: 0.1910 | 累计平均损失: 0.2312\n",
      "Epoch: 27/50 | Batch: 200/782 | 单Batch损失: 0.3840 | 累计平均损失: 0.2365\n",
      "Epoch: 27/50 | Batch: 300/782 | 单Batch损失: 0.1632 | 累计平均损失: 0.2367\n",
      "Epoch: 27/50 | Batch: 400/782 | 单Batch损失: 0.2913 | 累计平均损失: 0.2333\n",
      "Epoch: 27/50 | Batch: 500/782 | 单Batch损失: 0.3134 | 累计平均损失: 0.2328\n",
      "Epoch: 27/50 | Batch: 600/782 | 单Batch损失: 0.1631 | 累计平均损失: 0.2342\n",
      "Epoch: 27/50 | Batch: 700/782 | 单Batch损失: 0.2806 | 累计平均损失: 0.2337\n",
      "Epoch 27/50 完成 | 耗时: 63.20s | 训练准确率: 91.81% | 测试准确率: 88.69%\n",
      "Epoch: 28/50 | Batch: 100/782 | 单Batch损失: 0.2078 | 累计平均损失: 0.2163\n",
      "Epoch: 28/50 | Batch: 200/782 | 单Batch损失: 0.1341 | 累计平均损失: 0.2195\n",
      "Epoch: 28/50 | Batch: 300/782 | 单Batch损失: 0.0757 | 累计平均损失: 0.2200\n",
      "Epoch: 28/50 | Batch: 400/782 | 单Batch损失: 0.1576 | 累计平均损失: 0.2222\n",
      "Epoch: 28/50 | Batch: 500/782 | 单Batch损失: 0.2282 | 累计平均损失: 0.2260\n",
      "Epoch: 28/50 | Batch: 600/782 | 单Batch损失: 0.2603 | 累计平均损失: 0.2237\n",
      "Epoch: 28/50 | Batch: 700/782 | 单Batch损失: 0.3284 | 累计平均损失: 0.2232\n",
      "Epoch 28/50 完成 | 耗时: 80.36s | 训练准确率: 92.22% | 测试准确率: 88.81%\n",
      "Epoch: 29/50 | Batch: 100/782 | 单Batch损失: 0.1633 | 累计平均损失: 0.2198\n",
      "Epoch: 29/50 | Batch: 200/782 | 单Batch损失: 0.1148 | 累计平均损失: 0.2193\n",
      "Epoch: 29/50 | Batch: 300/782 | 单Batch损失: 0.1129 | 累计平均损失: 0.2186\n",
      "Epoch: 29/50 | Batch: 400/782 | 单Batch损失: 0.1436 | 累计平均损失: 0.2200\n",
      "Epoch: 29/50 | Batch: 500/782 | 单Batch损失: 0.3171 | 累计平均损失: 0.2224\n",
      "Epoch: 29/50 | Batch: 600/782 | 单Batch损失: 0.1653 | 累计平均损失: 0.2221\n",
      "Epoch: 29/50 | Batch: 700/782 | 单Batch损失: 0.2816 | 累计平均损失: 0.2217\n",
      "Epoch 29/50 完成 | 耗时: 74.72s | 训练准确率: 92.23% | 测试准确率: 88.78%\n",
      "Epoch: 30/50 | Batch: 100/782 | 单Batch损失: 0.2561 | 累计平均损失: 0.2105\n",
      "Epoch: 30/50 | Batch: 200/782 | 单Batch损失: 0.0962 | 累计平均损失: 0.2091\n",
      "Epoch: 30/50 | Batch: 300/782 | 单Batch损失: 0.1850 | 累计平均损失: 0.2069\n",
      "Epoch: 30/50 | Batch: 400/782 | 单Batch损失: 0.1692 | 累计平均损失: 0.2086\n",
      "Epoch: 30/50 | Batch: 500/782 | 单Batch损失: 0.2072 | 累计平均损失: 0.2089\n",
      "Epoch: 30/50 | Batch: 600/782 | 单Batch损失: 0.1508 | 累计平均损失: 0.2110\n",
      "Epoch: 30/50 | Batch: 700/782 | 单Batch损失: 0.2121 | 累计平均损失: 0.2122\n",
      "Epoch 30/50 完成 | 耗时: 51.10s | 训练准确率: 92.45% | 测试准确率: 89.09%\n",
      "Epoch: 31/50 | Batch: 100/782 | 单Batch损失: 0.1330 | 累计平均损失: 0.1954\n",
      "Epoch: 31/50 | Batch: 200/782 | 单Batch损失: 0.2532 | 累计平均损失: 0.2058\n",
      "Epoch: 31/50 | Batch: 300/782 | 单Batch损失: 0.1695 | 累计平均损失: 0.2046\n",
      "Epoch: 31/50 | Batch: 400/782 | 单Batch损失: 0.1964 | 累计平均损失: 0.2045\n",
      "Epoch: 31/50 | Batch: 500/782 | 单Batch损失: 0.0687 | 累计平均损失: 0.2040\n",
      "Epoch: 31/50 | Batch: 600/782 | 单Batch损失: 0.4410 | 累计平均损失: 0.2047\n",
      "Epoch: 31/50 | Batch: 700/782 | 单Batch损失: 0.1006 | 累计平均损失: 0.2059\n",
      "Epoch 31/50 完成 | 耗时: 57.40s | 训练准确率: 92.72% | 测试准确率: 89.32%\n",
      "Epoch: 32/50 | Batch: 100/782 | 单Batch损失: 0.1012 | 累计平均损失: 0.1954\n",
      "Epoch: 32/50 | Batch: 200/782 | 单Batch损失: 0.2048 | 累计平均损失: 0.1974\n",
      "Epoch: 32/50 | Batch: 300/782 | 单Batch损失: 0.4336 | 累计平均损失: 0.1986\n",
      "Epoch: 32/50 | Batch: 400/782 | 单Batch损失: 0.1788 | 累计平均损失: 0.2033\n",
      "Epoch: 32/50 | Batch: 500/782 | 单Batch损失: 0.1836 | 累计平均损失: 0.2022\n",
      "Epoch: 32/50 | Batch: 600/782 | 单Batch损失: 0.1269 | 累计平均损失: 0.2021\n",
      "Epoch: 32/50 | Batch: 700/782 | 单Batch损失: 0.2143 | 累计平均损失: 0.2047\n",
      "Epoch 32/50 完成 | 耗时: 50.97s | 训练准确率: 92.78% | 测试准确率: 89.22%\n",
      "Epoch: 33/50 | Batch: 100/782 | 单Batch损失: 0.1374 | 累计平均损失: 0.1842\n",
      "Epoch: 33/50 | Batch: 200/782 | 单Batch损失: 0.0895 | 累计平均损失: 0.1901\n",
      "Epoch: 33/50 | Batch: 300/782 | 单Batch损失: 0.1727 | 累计平均损失: 0.1937\n",
      "Epoch: 33/50 | Batch: 400/782 | 单Batch损失: 0.1783 | 累计平均损失: 0.1945\n",
      "Epoch: 33/50 | Batch: 500/782 | 单Batch损失: 0.1266 | 累计平均损失: 0.1949\n",
      "Epoch: 33/50 | Batch: 600/782 | 单Batch损失: 0.1565 | 累计平均损失: 0.1944\n",
      "Epoch: 33/50 | Batch: 700/782 | 单Batch损失: 0.1922 | 累计平均损失: 0.1945\n",
      "Epoch 33/50 完成 | 耗时: 50.85s | 训练准确率: 93.14% | 测试准确率: 89.33%\n",
      "Epoch: 34/50 | Batch: 100/782 | 单Batch损失: 0.1293 | 累计平均损失: 0.2027\n",
      "Epoch: 34/50 | Batch: 200/782 | 单Batch损失: 0.1487 | 累计平均损失: 0.1986\n",
      "Epoch: 34/50 | Batch: 300/782 | 单Batch损失: 0.1553 | 累计平均损失: 0.1969\n",
      "Epoch: 34/50 | Batch: 400/782 | 单Batch损失: 0.1961 | 累计平均损失: 0.1978\n",
      "Epoch: 34/50 | Batch: 500/782 | 单Batch损失: 0.1541 | 累计平均损失: 0.1956\n",
      "Epoch: 34/50 | Batch: 600/782 | 单Batch损失: 0.2765 | 累计平均损失: 0.1940\n",
      "Epoch: 34/50 | Batch: 700/782 | 单Batch损失: 0.3413 | 累计平均损失: 0.1946\n",
      "Epoch 34/50 完成 | 耗时: 49.00s | 训练准确率: 93.17% | 测试准确率: 89.47%\n",
      "Epoch: 35/50 | Batch: 100/782 | 单Batch损失: 0.2093 | 累计平均损失: 0.1851\n",
      "Epoch: 35/50 | Batch: 200/782 | 单Batch损失: 0.1467 | 累计平均损失: 0.1864\n",
      "Epoch: 35/50 | Batch: 300/782 | 单Batch损失: 0.1454 | 累计平均损失: 0.1834\n",
      "Epoch: 35/50 | Batch: 400/782 | 单Batch损失: 0.2127 | 累计平均损失: 0.1838\n",
      "Epoch: 35/50 | Batch: 500/782 | 单Batch损失: 0.2117 | 累计平均损失: 0.1856\n",
      "Epoch: 35/50 | Batch: 600/782 | 单Batch损失: 0.0858 | 累计平均损失: 0.1846\n",
      "Epoch: 35/50 | Batch: 700/782 | 单Batch损失: 0.2139 | 累计平均损失: 0.1863\n",
      "Epoch 35/50 完成 | 耗时: 71.60s | 训练准确率: 93.61% | 测试准确率: 89.61%\n",
      "Epoch: 36/50 | Batch: 100/782 | 单Batch损失: 0.1055 | 累计平均损失: 0.1911\n",
      "Epoch: 36/50 | Batch: 200/782 | 单Batch损失: 0.2387 | 累计平均损失: 0.1828\n",
      "Epoch: 36/50 | Batch: 300/782 | 单Batch损失: 0.2092 | 累计平均损失: 0.1828\n",
      "Epoch: 36/50 | Batch: 400/782 | 单Batch损失: 0.1390 | 累计平均损失: 0.1829\n",
      "Epoch: 36/50 | Batch: 500/782 | 单Batch损失: 0.1597 | 累计平均损失: 0.1848\n",
      "Epoch: 36/50 | Batch: 600/782 | 单Batch损失: 0.2191 | 累计平均损失: 0.1844\n",
      "Epoch: 36/50 | Batch: 700/782 | 单Batch损失: 0.2329 | 累计平均损失: 0.1844\n",
      "Epoch 36/50 完成 | 耗时: 82.24s | 训练准确率: 93.35% | 测试准确率: 89.55%\n",
      "Epoch: 37/50 | Batch: 100/782 | 单Batch损失: 0.2323 | 累计平均损失: 0.1669\n",
      "Epoch: 37/50 | Batch: 200/782 | 单Batch损失: 0.3011 | 累计平均损失: 0.1693\n",
      "Epoch: 37/50 | Batch: 300/782 | 单Batch损失: 0.1559 | 累计平均损失: 0.1764\n",
      "Epoch: 37/50 | Batch: 400/782 | 单Batch损失: 0.2042 | 累计平均损失: 0.1775\n",
      "Epoch: 37/50 | Batch: 500/782 | 单Batch损失: 0.2905 | 累计平均损失: 0.1791\n",
      "Epoch: 37/50 | Batch: 600/782 | 单Batch损失: 0.1836 | 累计平均损失: 0.1795\n",
      "Epoch: 37/50 | Batch: 700/782 | 单Batch损失: 0.0844 | 累计平均损失: 0.1789\n",
      "Epoch 37/50 完成 | 耗时: 81.55s | 训练准确率: 93.87% | 测试准确率: 89.33%\n",
      "Epoch: 38/50 | Batch: 100/782 | 单Batch损失: 0.2374 | 累计平均损失: 0.1650\n",
      "Epoch: 38/50 | Batch: 200/782 | 单Batch损失: 0.2358 | 累计平均损失: 0.1669\n",
      "Epoch: 38/50 | Batch: 300/782 | 单Batch损失: 0.1836 | 累计平均损失: 0.1724\n",
      "Epoch: 38/50 | Batch: 400/782 | 单Batch损失: 0.1060 | 累计平均损失: 0.1717\n",
      "Epoch: 38/50 | Batch: 500/782 | 单Batch损失: 0.1447 | 累计平均损失: 0.1717\n",
      "Epoch: 38/50 | Batch: 600/782 | 单Batch损失: 0.2479 | 累计平均损失: 0.1750\n",
      "Epoch: 38/50 | Batch: 700/782 | 单Batch损失: 0.1666 | 累计平均损失: 0.1759\n",
      "Epoch 38/50 完成 | 耗时: 81.31s | 训练准确率: 93.77% | 测试准确率: 89.64%\n",
      "Epoch: 39/50 | Batch: 100/782 | 单Batch损失: 0.0714 | 累计平均损失: 0.1656\n",
      "Epoch: 39/50 | Batch: 200/782 | 单Batch损失: 0.2346 | 累计平均损失: 0.1699\n",
      "Epoch: 39/50 | Batch: 300/782 | 单Batch损失: 0.2008 | 累计平均损失: 0.1710\n",
      "Epoch: 39/50 | Batch: 400/782 | 单Batch损失: 0.2054 | 累计平均损失: 0.1708\n",
      "Epoch: 39/50 | Batch: 500/782 | 单Batch损失: 0.1076 | 累计平均损失: 0.1703\n",
      "Epoch: 39/50 | Batch: 600/782 | 单Batch损失: 0.0607 | 累计平均损失: 0.1686\n",
      "Epoch: 39/50 | Batch: 700/782 | 单Batch损失: 0.2755 | 累计平均损失: 0.1683\n",
      "Epoch 39/50 完成 | 耗时: 81.15s | 训练准确率: 93.95% | 测试准确率: 89.67%\n",
      "Epoch: 40/50 | Batch: 100/782 | 单Batch损失: 0.1794 | 累计平均损失: 0.1669\n",
      "Epoch: 40/50 | Batch: 200/782 | 单Batch损失: 0.0493 | 累计平均损失: 0.1678\n",
      "Epoch: 40/50 | Batch: 300/782 | 单Batch损失: 0.2379 | 累计平均损失: 0.1690\n",
      "Epoch: 40/50 | Batch: 400/782 | 单Batch损失: 0.1025 | 累计平均损失: 0.1690\n",
      "Epoch: 40/50 | Batch: 500/782 | 单Batch损失: 0.1547 | 累计平均损失: 0.1701\n",
      "Epoch: 40/50 | Batch: 600/782 | 单Batch损失: 0.0876 | 累计平均损失: 0.1703\n",
      "Epoch: 40/50 | Batch: 700/782 | 单Batch损失: 0.1686 | 累计平均损失: 0.1702\n",
      "Epoch 40/50 完成 | 耗时: 67.61s | 训练准确率: 94.01% | 测试准确率: 89.84%\n",
      "Epoch: 41/50 | Batch: 100/782 | 单Batch损失: 0.1905 | 累计平均损失: 0.1635\n",
      "Epoch: 41/50 | Batch: 200/782 | 单Batch损失: 0.1010 | 累计平均损失: 0.1635\n",
      "Epoch: 41/50 | Batch: 300/782 | 单Batch损失: 0.2289 | 累计平均损失: 0.1663\n",
      "Epoch: 41/50 | Batch: 400/782 | 单Batch损失: 0.1762 | 累计平均损失: 0.1655\n",
      "Epoch: 41/50 | Batch: 500/782 | 单Batch损失: 0.1919 | 累计平均损失: 0.1659\n",
      "Epoch: 41/50 | Batch: 600/782 | 单Batch损失: 0.1375 | 累计平均损失: 0.1659\n",
      "Epoch: 41/50 | Batch: 700/782 | 单Batch损失: 0.1894 | 累计平均损失: 0.1646\n",
      "Epoch 41/50 完成 | 耗时: 81.80s | 训练准确率: 94.15% | 测试准确率: 89.82%\n",
      "Epoch: 42/50 | Batch: 100/782 | 单Batch损失: 0.1321 | 累计平均损失: 0.1552\n",
      "Epoch: 42/50 | Batch: 200/782 | 单Batch损失: 0.1208 | 累计平均损失: 0.1530\n",
      "Epoch: 42/50 | Batch: 300/782 | 单Batch损失: 0.1458 | 累计平均损失: 0.1543\n",
      "Epoch: 42/50 | Batch: 400/782 | 单Batch损失: 0.1978 | 累计平均损失: 0.1554\n",
      "Epoch: 42/50 | Batch: 500/782 | 单Batch损失: 0.1350 | 累计平均损失: 0.1571\n",
      "Epoch: 42/50 | Batch: 600/782 | 单Batch损失: 0.1054 | 累计平均损失: 0.1584\n",
      "Epoch: 42/50 | Batch: 700/782 | 单Batch损失: 0.1255 | 累计平均损失: 0.1587\n",
      "Epoch 42/50 完成 | 耗时: 68.28s | 训练准确率: 94.42% | 测试准确率: 89.68%\n",
      "Epoch: 43/50 | Batch: 100/782 | 单Batch损失: 0.2327 | 累计平均损失: 0.1462\n",
      "Epoch: 43/50 | Batch: 200/782 | 单Batch损失: 0.2214 | 累计平均损失: 0.1514\n",
      "Epoch: 43/50 | Batch: 300/782 | 单Batch损失: 0.1359 | 累计平均损失: 0.1488\n",
      "Epoch: 43/50 | Batch: 400/782 | 单Batch损失: 0.2362 | 累计平均损失: 0.1500\n",
      "Epoch: 43/50 | Batch: 500/782 | 单Batch损失: 0.1305 | 累计平均损失: 0.1501\n",
      "Epoch: 43/50 | Batch: 600/782 | 单Batch损失: 0.1552 | 累计平均损失: 0.1528\n",
      "Epoch: 43/50 | Batch: 700/782 | 单Batch损失: 0.0895 | 累计平均损失: 0.1531\n",
      "Epoch 43/50 完成 | 耗时: 48.83s | 训练准确率: 94.59% | 测试准确率: 89.91%\n",
      "Epoch: 44/50 | Batch: 100/782 | 单Batch损失: 0.1532 | 累计平均损失: 0.1545\n",
      "Epoch: 44/50 | Batch: 200/782 | 单Batch损失: 0.2617 | 累计平均损失: 0.1534\n",
      "Epoch: 44/50 | Batch: 300/782 | 单Batch损失: 0.2021 | 累计平均损失: 0.1534\n",
      "Epoch: 44/50 | Batch: 400/782 | 单Batch损失: 0.1155 | 累计平均损失: 0.1527\n",
      "Epoch: 44/50 | Batch: 500/782 | 单Batch损失: 0.0798 | 累计平均损失: 0.1519\n",
      "Epoch: 44/50 | Batch: 600/782 | 单Batch损失: 0.1413 | 累计平均损失: 0.1532\n",
      "Epoch: 44/50 | Batch: 700/782 | 单Batch损失: 0.1824 | 累计平均损失: 0.1544\n",
      "Epoch 44/50 完成 | 耗时: 48.27s | 训练准确率: 94.53% | 测试准确率: 89.98%\n",
      "Epoch: 45/50 | Batch: 100/782 | 单Batch损失: 0.2251 | 累计平均损失: 0.1506\n",
      "Epoch: 45/50 | Batch: 200/782 | 单Batch损失: 0.1273 | 累计平均损失: 0.1457\n",
      "Epoch: 45/50 | Batch: 300/782 | 单Batch损失: 0.1685 | 累计平均损失: 0.1443\n",
      "Epoch: 45/50 | Batch: 400/782 | 单Batch损失: 0.1954 | 累计平均损失: 0.1449\n",
      "Epoch: 45/50 | Batch: 500/782 | 单Batch损失: 0.0879 | 累计平均损失: 0.1455\n",
      "Epoch: 45/50 | Batch: 600/782 | 单Batch损失: 0.3393 | 累计平均损失: 0.1445\n",
      "Epoch: 45/50 | Batch: 700/782 | 单Batch损失: 0.1599 | 累计平均损失: 0.1447\n",
      "Epoch 45/50 完成 | 耗时: 47.46s | 训练准确率: 94.94% | 测试准确率: 90.15%\n",
      "Epoch: 46/50 | Batch: 100/782 | 单Batch损失: 0.0921 | 累计平均损失: 0.1571\n",
      "Epoch: 46/50 | Batch: 200/782 | 单Batch损失: 0.0767 | 累计平均损失: 0.1518\n",
      "Epoch: 46/50 | Batch: 300/782 | 单Batch损失: 0.1400 | 累计平均损失: 0.1521\n",
      "Epoch: 46/50 | Batch: 400/782 | 单Batch损失: 0.1224 | 累计平均损失: 0.1483\n",
      "Epoch: 46/50 | Batch: 500/782 | 单Batch损失: 0.1307 | 累计平均损失: 0.1463\n",
      "Epoch: 46/50 | Batch: 600/782 | 单Batch损失: 0.1079 | 累计平均损失: 0.1465\n",
      "Epoch: 46/50 | Batch: 700/782 | 单Batch损失: 0.2093 | 累计平均损失: 0.1462\n",
      "Epoch 46/50 完成 | 耗时: 47.49s | 训练准确率: 94.91% | 测试准确率: 89.90%\n",
      "Epoch: 47/50 | Batch: 100/782 | 单Batch损失: 0.2271 | 累计平均损失: 0.1398\n",
      "Epoch: 47/50 | Batch: 200/782 | 单Batch损失: 0.0876 | 累计平均损失: 0.1420\n",
      "Epoch: 47/50 | Batch: 300/782 | 单Batch损失: 0.2563 | 累计平均损失: 0.1465\n",
      "Epoch: 47/50 | Batch: 400/782 | 单Batch损失: 0.1245 | 累计平均损失: 0.1445\n",
      "Epoch: 47/50 | Batch: 500/782 | 单Batch损失: 0.1176 | 累计平均损失: 0.1448\n",
      "Epoch: 47/50 | Batch: 600/782 | 单Batch损失: 0.1681 | 累计平均损失: 0.1447\n",
      "Epoch: 47/50 | Batch: 700/782 | 单Batch损失: 0.1941 | 累计平均损失: 0.1437\n",
      "Epoch 47/50 完成 | 耗时: 47.45s | 训练准确率: 95.07% | 测试准确率: 90.03%\n",
      "Epoch: 48/50 | Batch: 100/782 | 单Batch损失: 0.1503 | 累计平均损失: 0.1361\n",
      "Epoch: 48/50 | Batch: 200/782 | 单Batch损失: 0.0962 | 累计平均损失: 0.1404\n",
      "Epoch: 48/50 | Batch: 300/782 | 单Batch损失: 0.4808 | 累计平均损失: 0.1447\n",
      "Epoch: 48/50 | Batch: 400/782 | 单Batch损失: 0.1307 | 累计平均损失: 0.1465\n",
      "Epoch: 48/50 | Batch: 500/782 | 单Batch损失: 0.0648 | 累计平均损失: 0.1444\n",
      "Epoch: 48/50 | Batch: 600/782 | 单Batch损失: 0.1002 | 累计平均损失: 0.1438\n",
      "Epoch: 48/50 | Batch: 700/782 | 单Batch损失: 0.2035 | 累计平均损失: 0.1424\n",
      "Epoch 48/50 完成 | 耗时: 47.78s | 训练准确率: 94.93% | 测试准确率: 90.27%\n",
      "Epoch: 49/50 | Batch: 100/782 | 单Batch损失: 0.0835 | 累计平均损失: 0.1356\n",
      "Epoch: 49/50 | Batch: 200/782 | 单Batch损失: 0.0732 | 累计平均损失: 0.1360\n",
      "Epoch: 49/50 | Batch: 300/782 | 单Batch损失: 0.2437 | 累计平均损失: 0.1371\n",
      "Epoch: 49/50 | Batch: 400/782 | 单Batch损失: 0.1142 | 累计平均损失: 0.1361\n",
      "Epoch: 49/50 | Batch: 500/782 | 单Batch损失: 0.0778 | 累计平均损失: 0.1368\n",
      "Epoch: 49/50 | Batch: 600/782 | 单Batch损失: 0.0833 | 累计平均损失: 0.1368\n",
      "Epoch: 49/50 | Batch: 700/782 | 单Batch损失: 0.1409 | 累计平均损失: 0.1388\n",
      "Epoch 49/50 完成 | 耗时: 48.56s | 训练准确率: 95.19% | 测试准确率: 90.02%\n",
      "Epoch: 50/50 | Batch: 100/782 | 单Batch损失: 0.1375 | 累计平均损失: 0.1370\n",
      "Epoch: 50/50 | Batch: 200/782 | 单Batch损失: 0.0816 | 累计平均损失: 0.1380\n",
      "Epoch: 50/50 | Batch: 300/782 | 单Batch损失: 0.2015 | 累计平均损失: 0.1382\n",
      "Epoch: 50/50 | Batch: 400/782 | 单Batch损失: 0.1428 | 累计平均损失: 0.1400\n",
      "Epoch: 50/50 | Batch: 500/782 | 单Batch损失: 0.1029 | 累计平均损失: 0.1391\n",
      "Epoch: 50/50 | Batch: 600/782 | 单Batch损失: 0.1645 | 累计平均损失: 0.1391\n",
      "Epoch: 50/50 | Batch: 700/782 | 单Batch损失: 0.1572 | 累计平均损失: 0.1391\n",
      "Epoch 50/50 完成 | 耗时: 48.92s | 训练准确率: 95.15% | 测试准确率: 90.15%\n",
      "\n",
      "训练完成! 开始绘制结果图表...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练完成！最终测试准确率: 90.15%\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "# ======================================================================\n",
    "# 4. 结合了分阶段策略和详细打印的训练函数\n",
    "# ======================================================================\n",
    "def set_trainable_layers(model, trainable_parts):\n",
    "    print(f\"\\n---> 解冻以下部分并设为可训练: {trainable_parts}\")\n",
    "    for name, param in model.named_parameters():\n",
    "        param.requires_grad = False\n",
    "        for part in trainable_parts:\n",
    "            if part in name:\n",
    "                param.requires_grad = True\n",
    "                break\n",
    "\n",
    "def train_staged_finetuning(model, criterion, train_loader, test_loader, device, epochs):\n",
    "    optimizer = None\n",
    "    \n",
    "    # 初始化历史记录列表，与你的要求一致\n",
    "    all_iter_losses, iter_indices = [], []\n",
    "    train_acc_history, test_acc_history = [], []\n",
    "    train_loss_history, test_loss_history = [], []\n",
    "\n",
    "    for epoch in range(1, epochs + 1):\n",
    "        epoch_start_time = time.time()\n",
    "        \n",
    "        # --- 动态调整学习率和冻结层 ---\n",
    "        if epoch == 1:\n",
    "            print(\"\\n\" + \"=\"*50 + \"\\n🚀 **阶段 1：训练注意力模块和分类头**\\n\" + \"=\"*50)\n",
    "            set_trainable_layers(model, [\"cbam\", \"backbone.fc\"])\n",
    "            optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3)\n",
    "        elif epoch == 6:\n",
    "            print(\"\\n\" + \"=\"*50 + \"\\n✈️ **阶段 2：解冻高层卷积层 (layer3, layer4)**\\n\" + \"=\"*50)\n",
    "            set_trainable_layers(model, [\"cbam\", \"backbone.fc\", \"backbone.layer3\", \"backbone.layer4\"])\n",
    "            optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-4)\n",
    "        elif epoch == 21:\n",
    "            print(\"\\n\" + \"=\"*50 + \"\\n🛰️ **阶段 3：解冻所有层，进行全局微调**\\n\" + \"=\"*50)\n",
    "            for param in model.parameters(): param.requires_grad = True\n",
    "            optimizer = optim.Adam(model.parameters(), lr=1e-5)\n",
    "        \n",
    "        # --- 训练循环 ---\n",
    "        model.train()\n",
    "        running_loss, correct, total = 0.0, 0, 0\n",
    "        for batch_idx, (data, target) in enumerate(train_loader):\n",
    "            data, target = data.to(device), target.to(device)\n",
    "            optimizer.zero_grad()\n",
    "            output = model(data)\n",
    "            loss = criterion(output, target)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            \n",
    "            # 记录每个iteration的损失\n",
    "            iter_loss = loss.item()\n",
    "            all_iter_losses.append(iter_loss)\n",
    "            iter_indices.append((epoch - 1) * len(train_loader) + batch_idx + 1)\n",
    "            \n",
    "            running_loss += iter_loss\n",
    "            _, predicted = output.max(1)\n",
    "            total += target.size(0)\n",
    "            correct += predicted.eq(target).sum().item()\n",
    "            \n",
    "            # 按你的要求，每100个batch打印一次\n",
    "            if (batch_idx + 1) % 100 == 0:\n",
    "                print(f'Epoch: {epoch}/{epochs} | Batch: {batch_idx+1}/{len(train_loader)} '\n",
    "                      f'| 单Batch损失: {iter_loss:.4f} | 累计平均损失: {running_loss/(batch_idx+1):.4f}')\n",
    "        \n",
    "        epoch_train_loss = running_loss / len(train_loader)\n",
    "        epoch_train_acc = 100. * correct / total\n",
    "        train_loss_history.append(epoch_train_loss)\n",
    "        train_acc_history.append(epoch_train_acc)\n",
    "\n",
    "        # --- 测试循环 ---\n",
    "        model.eval()\n",
    "        test_loss, correct_test, total_test = 0, 0, 0\n",
    "        with torch.no_grad():\n",
    "            for data, target in test_loader:\n",
    "                data, target = data.to(device), target.to(device)\n",
    "                output = model(data)\n",
    "                test_loss += criterion(output, target).item()\n",
    "                _, predicted = output.max(1)\n",
    "                total_test += target.size(0)\n",
    "                correct_test += predicted.eq(target).sum().item()\n",
    "        \n",
    "        epoch_test_loss = test_loss / len(test_loader)\n",
    "        epoch_test_acc = 100. * correct_test / total_test\n",
    "        test_loss_history.append(epoch_test_loss)\n",
    "        test_acc_history.append(epoch_test_acc)\n",
    "        \n",
    "        # 打印每个epoch的最终结果\n",
    "        print(f'Epoch {epoch}/{epochs} 完成 | 耗时: {time.time() - epoch_start_time:.2f}s | 训练准确率: {epoch_train_acc:.2f}% | 测试准确率: {epoch_test_acc:.2f}%')\n",
    "    \n",
    "    # 训练结束后调用绘图函数\n",
    "    print(\"\\n训练完成! 开始绘制结果图表...\")\n",
    "    plot_iter_losses(all_iter_losses, iter_indices)\n",
    "    plot_epoch_metrics(train_acc_history, test_acc_history, train_loss_history, test_loss_history)\n",
    "    \n",
    "    # 返回最终的测试准确率\n",
    "    return epoch_test_acc\n",
    "\n",
    "# ======================================================================\n",
    "# 5. 绘图函数定义\n",
    "# ======================================================================\n",
    "def plot_iter_losses(losses, indices):\n",
    "    plt.figure(figsize=(10, 4))\n",
    "    plt.plot(indices, losses, 'b-', alpha=0.7, label='Iteration Loss')\n",
    "    plt.xlabel('Iteration（Batch序号）')\n",
    "    plt.ylabel('损失值')\n",
    "    plt.title('每个 Iteration 的训练损失')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "def plot_epoch_metrics(train_acc, test_acc, train_loss, test_loss):\n",
    "    epochs = range(1, len(train_acc) + 1)\n",
    "    plt.figure(figsize=(12, 4))\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(epochs, train_acc, 'b-', label='训练准确率')\n",
    "    plt.plot(epochs, test_acc, 'r-', label='测试准确率')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('准确率 (%)')\n",
    "    plt.title('训练和测试准确率')\n",
    "    plt.legend(); plt.grid(True)\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.plot(epochs, train_loss, 'b-', label='训练损失')\n",
    "    plt.plot(epochs, test_loss, 'r-', label='测试损失')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('损失值')\n",
    "    plt.title('训练和测试损失')\n",
    "    plt.legend(); plt.grid(True)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "# ======================================================================\n",
    "# 6. 执行训练\n",
    "# ======================================================================\n",
    "model = ResNet18_CBAM().to(device)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "epochs = 50\n",
    "\n",
    "print(\"开始使用带分阶段微调策略的ResNet18+CBAM模型进行训练...\")\n",
    "final_accuracy = train_staged_finetuning(model, criterion, train_loader, test_loader, device, epochs)\n",
    "print(f\"训练完成！最终测试准确率: {final_accuracy:.2f}%\")\n",
    "\n",
    "# torch.save(model.state_dict(), 'resnet18_cbam_finetuned.pth')\n",
    "# print(\"模型已保存为: resnet18_cbam_finetuned.pth\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到准确率还在持续上升，说明模型还没有收敛，对预训练模型采用cbam注意力显著增强了训练精度。\n",
    "\n",
    "保存下目前的权重，未来可以继续训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型已保存为: resnet18_cbam_finetuned.pth\n"
     ]
    }
   ],
   "source": [
    "torch.save(model.state_dict(), 'resnet18_cbam_finetuned.pth')\n",
    "print(\"模型已保存为: resnet18_cbam_finetuned.pth\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "yolov5_new",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
